home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / Anwendun / 7UP_PD / FORMEL1.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-17  |  18.3 KB  |  929 lines
  1. /* Auswertung von Ausdrücken */
  2. /* Output from p2c, the Pascal-to-C translator */
  3. /* From input file "formel1.pas" */
  4.  
  5. #include <portab.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8.  
  9. unsigned short var_anz = 0;
  10.  
  11. #define max_var_anz 10
  12. #define var_anz 0   /*aktuelle Anzahl der Variablen*/
  13.  
  14. typedef struct
  15. {
  16.     char var_name[11] ;
  17.     double var_wert;
  18. }var_typ;
  19.  
  20. var_typ var_liste[max_var_anz];
  21.  
  22. char *ohne_blanks(char *s)
  23. { /*Alle Blanks eines Strings löschen*/
  24.     char *p;
  25.     p = strchr(s, ' ');
  26.     while (p != 0L)
  27.     {
  28.         strcpy(p, &p[1]);
  29.         p = strchr(s, ' ');
  30.     }
  31.     return s;
  32. }
  33.  
  34. int var_vorhanden(char *var_name, double *var_wert, char *var_nr)
  35. {
  36.     int vorh;
  37.     
  38.     vorh = FALSE;
  39.     *var_nr = 0;
  40.     while (!vorh && *var_nr < var_anz) 
  41.     {
  42.         (*var_nr)++;
  43.         if (ohne_blanks(var_liste[*var_nr - 1].var_name) == ohne_blanks(var_name)) 
  44.         {
  45.             *var_wert = var_liste[*var_nr - 1].var_wert;
  46.             vorh = TRUE;
  47.         }
  48.     }
  49.     return vorh;
  50. }
  51.  
  52. #define maxkli          30   /*Anzahl Klammerebenen*/
  53.  
  54. typedef enum 
  55. {
  56.     start, 
  57.     variable, 
  58.     variende, 
  59.     konstante, 
  60.     konstende, 
  61.     operator1, 
  62.     operator2,
  63.     vorzeichen, 
  64.     klauf1, 
  65.     klauf2, 
  66.     klzu1, 
  67.     klzu2, 
  68.     fehler, 
  69.     ende
  70. } zust_typ;
  71.  
  72. typedef struct klreg_typ 
  73. {
  74.     double reg1, reg2;
  75.     char op1, op2;
  76.     int vorz;
  77.     char anz;
  78. } klreg_typ;
  79.  
  80.  
  81. /* Local variables for entwicklung: */
  82. struct LOC_entwicklung 
  83. {
  84.     char ausdruck[256];
  85.     double unter_grenze, ober_grenze, *ergebnis;
  86.     int *fcode;
  87.     zust_typ zust;
  88.     double xreg, yreg, zreg;
  89.     char kli, opanz;
  90.     klreg_typ klreg[maxkli];
  91.     char op[3];
  92.     char konst_str[256];   /*String für Konstante*/
  93.     char var_name[11];
  94.     double var_wert;
  95.     char var_nr, st_index, akt_pos;
  96.     int vorz;
  97.     short code;
  98.     int fertig;
  99. } ;
  100.  
  101. static void op2_auf_op1(struct LOC_entwicklung *LINK)
  102. {
  103.     LINK->yreg = LINK->xreg;
  104.     LINK->op[0] = LINK->op[1];
  105.     LINK->opanz = 1;
  106. }
  107.  
  108. static void berechnen(struct LOC_entwicklung *LINK)
  109. {
  110.     switch (LINK->opanz) 
  111.     {
  112.  
  113.         case 1:
  114.             LINK->yreg = LINK->xreg;
  115.             break;
  116.  
  117.         case 2:
  118.             switch (LINK->op[1]) 
  119.             {
  120.  
  121.                 case '*':
  122.                 case '/':
  123.                     switch (LINK->op[0]) 
  124.                     {
  125.  
  126.                         case '*':
  127.                             LINK->xreg = LINK->yreg * LINK->xreg;
  128.                             op2_auf_op1(LINK);
  129.                             break;
  130.  
  131.                         case '/':
  132.                             if (LINK->xreg == 0)
  133.                                 *LINK->fcode = 1;
  134.                             else 
  135.                             {
  136.                                 LINK->xreg = LINK->yreg / LINK->xreg;
  137.                                 op2_auf_op1(LINK);
  138.                             }
  139.                             break;
  140.  
  141.                         case '+':
  142.                         case '-':
  143.                             LINK->zreg = LINK->yreg;
  144.                             LINK->yreg = LINK->xreg;
  145.                             break;
  146.                     }
  147.                     break;
  148.  
  149.                 case '+':
  150.                 case '-':
  151.                     switch (LINK->op[0]) 
  152.                     {
  153.  
  154.                         case '*':
  155.                             LINK->xreg = LINK->yreg * LINK->xreg;
  156.                             op2_auf_op1(LINK);
  157.                             break;
  158.  
  159.                         case '/':
  160.                             if (LINK->xreg == 0)
  161.                                 *LINK->fcode = 1;
  162.                             else 
  163.                             {
  164.                                 LINK->xreg = LINK->yreg / LINK->xreg;
  165.                                 op2_auf_op1(LINK);
  166.                             }
  167.                             break;
  168.  
  169.                         case '+':
  170.                             LINK->xreg = LINK->yreg + LINK->xreg;
  171.                             op2_auf_op1(LINK);
  172.                             break;
  173.  
  174.                         case '-':
  175.                             LINK->xreg = LINK->yreg - LINK->xreg;
  176.                             op2_auf_op1(LINK);
  177.                             break;
  178.                     }
  179.                     break;
  180.                 }
  181.                 break;
  182.  
  183.             case 3:
  184.                 switch (LINK->op[1]) 
  185.                 {
  186.  
  187.                     case '*':
  188.                         LINK->xreg = LINK->yreg * LINK->xreg;
  189.                         LINK->yreg = LINK->xreg;
  190.                         break;
  191.  
  192.                     case '/':
  193.                         if (LINK->xreg == 0)
  194.                             *LINK->fcode = 1;
  195.                         else 
  196.                         {
  197.                             LINK->xreg = LINK->yreg / LINK->xreg;
  198.                             LINK->yreg = LINK->xreg;
  199.                         }
  200.                         break;
  201.                 }
  202.                 LINK->opanz = 2;
  203.                 LINK->op[1] = LINK->op[2];
  204.                 switch (LINK->op[1]) 
  205.                 {
  206.  
  207.                     case '+':
  208.                     case '-':
  209.                         switch (LINK->op[0]) 
  210.                         {
  211.  
  212.                             case '+':
  213.                                 LINK->xreg = LINK->zreg + LINK->xreg;
  214.                                 op2_auf_op1(LINK);
  215.                                 break;
  216.  
  217.                             case '-':
  218.                                 LINK->xreg = LINK->zreg - LINK->xreg;
  219.                                 op2_auf_op1(LINK);
  220.                                 break;
  221.                         }
  222.                         break;
  223.                 }
  224.                 break;
  225.             }
  226. }  /*berechnen*/
  227.  
  228. static void klammer_auf(struct LOC_entwicklung *LINK)
  229. {
  230.     if (LINK->kli >= maxkli) 
  231.     {   /*zu viele geöffnete Klammern*/
  232.         *LINK->fcode = 4;
  233.         return;
  234.     }
  235.     switch (LINK->opanz) 
  236.     {
  237.  
  238.         case 0:
  239.             LINK->kli++;
  240.             LINK->klreg[LINK->kli - 1].anz = 0;
  241.             break;
  242.  
  243.         case 1:
  244.             LINK->kli++;
  245.             LINK->klreg[LINK->kli - 1].reg1 = LINK->yreg;
  246.             LINK->klreg[LINK->kli - 1].op1 = LINK->op[0];
  247.             LINK->klreg[LINK->kli - 1].anz = 1;
  248.             break;
  249.         
  250.         case 2:
  251.             LINK->kli++;
  252.             LINK->klreg[LINK->kli - 1].reg1 = LINK->zreg;
  253.             LINK->klreg[LINK->kli - 1].op1 = LINK->op[0];
  254.             LINK->klreg[LINK->kli - 1].reg2 = LINK->yreg;
  255.             LINK->klreg[LINK->kli - 1].op2 = LINK->op[1];
  256.             LINK->klreg[LINK->kli - 1].anz = 2;
  257.             break;
  258.     }
  259.     LINK->klreg[LINK->kli - 1].vorz = LINK->vorz;
  260.     LINK->vorz = TRUE;
  261.     LINK->xreg = 0.0;
  262.     LINK->yreg = 0.0;
  263.     LINK->opanz = 0;
  264. }  /*klammer_auf*/
  265.  
  266. static void klammer_zu(struct LOC_entwicklung *LINK)
  267. {
  268.     if (LINK->kli <= 0) 
  269.     {   /*zu viele geschlossene Klammern*/
  270.         *LINK->fcode = 5;
  271.         return;
  272.     }
  273.     LINK->opanz++;
  274.     LINK->op[LINK->opanz - 1] = '+';
  275.     berechnen(LINK);
  276.     if (!LINK->klreg[LINK->kli - 1].vorz)
  277.         LINK->xreg = -LINK->xreg;
  278.     switch (LINK->klreg[LINK->kli - 1].anz) 
  279.     {
  280.  
  281.         case 0:
  282.             LINK->kli--;
  283.             LINK->opanz = 0;
  284.             break;
  285.         
  286.         case 1:
  287.             LINK->yreg = LINK->klreg[LINK->kli - 1].reg1;
  288.             LINK->op[0] = LINK->klreg[LINK->kli - 1].op1;
  289.             LINK->kli--;
  290.             LINK->opanz = 1;
  291.             break;
  292.             
  293.         case 2:
  294.             LINK->zreg = LINK->klreg[LINK->kli - 1].reg1;
  295.             LINK->op[0] = LINK->klreg[LINK->kli - 1].op1;
  296.             LINK->yreg = LINK->klreg[LINK->kli - 1].reg2;
  297.             LINK->op[1] = LINK->klreg[LINK->kli - 1].op2;
  298.             LINK->kli--;
  299.             LINK->opanz = 2;
  300.             break;
  301.     }
  302. }  /*klammer_zu*/
  303.  
  304. static void task(struct LOC_entwicklung *LINK)
  305. {
  306.     switch (LINK->zust) 
  307.     {
  308.  
  309.         case start:
  310.             LINK->st_index++;
  311. /*
  312.             case upcase(ausdruck[st_index]) of
  313. */
  314.             switch (LINK->ausdruck[LINK->st_index - 1]) 
  315.             {
  316.  
  317.                 case '+':
  318.                     LINK->vorz = TRUE;
  319.                     LINK->zust = vorzeichen;
  320.                     break;
  321.  
  322.                 case '-':
  323.                     LINK->vorz = FALSE;
  324.                     LINK->zust = vorzeichen;
  325.                     break;
  326.  
  327.                 case '(':
  328.                     LINK->zust = klauf1;
  329.                     break;
  330.  
  331.                 case ' ':
  332.                     /* blank case */
  333.                     break;
  334.  
  335.                 case '=':
  336.                 case '\0':
  337.                     LINK->zust = ende;
  338.                     break;
  339.  
  340.                 default:
  341.                     if (isdigit(LINK->ausdruck[LINK->st_index - 1]) ||
  342. /*
  343.                         LINK->ausdruck[LINK->st_index - 1] == ',' ||
  344. */
  345.                         LINK->ausdruck[LINK->st_index - 1] == '.') 
  346.                     {
  347.                         strcat(LINK->konst_str, " ");
  348.                         LINK->konst_str[strlen(LINK->konst_str) - 1] =
  349.                             LINK->ausdruck[LINK->st_index - 1];
  350.                         LINK->akt_pos = LINK->st_index;
  351.                         LINK->zust = konstante;
  352.                     } 
  353.                     else 
  354.                         if (isalpha(LINK->ausdruck[LINK->st_index - 1]) ||
  355.                             (LINK->ausdruck[LINK->st_index - 1] & 255) == 142 ||
  356.                             (LINK->ausdruck[LINK->st_index - 1] & 255) == 153 ||
  357.                             (LINK->ausdruck[LINK->st_index - 1] & 255) == 154) 
  358.                         {
  359. /*
  360.                             var_name:=upcase(ausdruck[st_index]);
  361. */
  362.                             LINK->var_name[0] = LINK->ausdruck[LINK->st_index - 1];
  363.                             LINK->var_name[1] = 0;
  364.                             LINK->akt_pos = LINK->st_index;
  365.                             LINK->zust = variable;
  366.                         } 
  367.                         else 
  368.                         {
  369.                             *LINK->fcode = 13;
  370.                             LINK->zust = fehler;
  371.                         }
  372.                     break;
  373.             }
  374.             break;
  375.  
  376.         case variable:
  377.             LINK->st_index++;
  378. /*
  379.             case upcase(ausdruck[st_index]) of
  380. */
  381.             switch (LINK->ausdruck[LINK->st_index - 1]) 
  382.             {
  383.  
  384.                 case '+':
  385.                 case '-':
  386.                 case '*':
  387.                 case '/':
  388.                     LINK->zust = operator1;
  389.                     break;
  390.                 
  391.                 case ')':
  392.                     LINK->zust = klzu1;
  393.                     break;
  394.                 
  395.                 case ' ':
  396.                     LINK->zust = variende;
  397.                     break;
  398.                 
  399.                 case '=':
  400.                 case '\0':
  401.                     LINK->zust = ende;
  402.                     break;
  403.                 
  404.                 default:
  405.                     if (isalpha(LINK->ausdruck[LINK->st_index - 1]) ||
  406.                         (LINK->ausdruck[LINK->st_index - 1] & 255) == 142 ||
  407.                         (LINK->ausdruck[LINK->st_index - 1] & 255) == 153 ||
  408.                         (LINK->ausdruck[LINK->st_index - 1] & 255) == 154 ||
  409.                          isdigit(LINK->ausdruck[LINK->st_index - 1])) 
  410.                     {
  411.                         strcat(LINK->var_name, " ");
  412.                         LINK->var_name[strlen(LINK->var_name) - 1] =
  413.                             LINK->ausdruck[LINK->st_index - 1];
  414. /*
  415.                         upcase(ausdruck[st_index]);
  416. */
  417.                     } 
  418.                     else 
  419.                     {
  420.                         *LINK->fcode = 7;
  421.                         LINK->zust = fehler;
  422.                     }
  423.                     break;
  424.             }
  425.             if (LINK->zust != variable && *LINK->fcode == 0) 
  426.             {
  427.                 if (var_vorhanden(LINK->var_name, &LINK->var_wert, &LINK->var_nr)) 
  428.                 {
  429.                     LINK->xreg = LINK->var_wert;
  430.                     if (!LINK->vorz) 
  431.                     {   /*negatives Vorzeichen ?*/
  432.                         LINK->xreg = -LINK->xreg;
  433.                         LINK->vorz = TRUE;   /*wieder auf positives Vorzeichen schalten*/
  434.                     }
  435.                 } 
  436.                 else 
  437.                 {
  438.                     *LINK->fcode = 17;
  439.                     LINK->zust = fehler;
  440.                 }
  441.             }
  442.             break;
  443.  
  444.         case variende:
  445.             LINK->st_index++;
  446. /*
  447.             case upcase(ausdruck[st_index]) of
  448. */
  449.             switch (LINK->ausdruck[LINK->st_index - 1]) 
  450.             {
  451.  
  452.                 case '+':
  453.                 case '-':
  454.                 case '*':
  455.                 case '/':
  456.                     LINK->zust = operator1;
  457.                     break;
  458.                 
  459.                 case ')':
  460.                     LINK->zust = klzu1;
  461.                     break;
  462.                 
  463.                 case ' ':
  464.                     /* blank case */
  465.                     break;
  466.                 
  467.                 case '=':
  468.                 case '\0':
  469.                     LINK->zust = ende;
  470.                     break;
  471.                 
  472.                 default:
  473.                     *LINK->fcode = 15;
  474.                     LINK->zust = fehler;
  475.                     break;
  476.             }
  477.             break;
  478.  
  479.         case konstante:
  480.             LINK->st_index++;
  481. /*
  482.             case upcase(ausdruck[st_index]) of
  483. */
  484.             switch (LINK->ausdruck[LINK->st_index - 1]) 
  485.             {
  486.  
  487.                 case '+':
  488.                 case '-':
  489.                 case '*':
  490.                 case '/':
  491.                     LINK->zust = operator1;
  492.                     break;
  493.                 
  494.                 case ')':
  495.                     LINK->zust = klzu1;
  496.                     break;
  497.                 
  498.                 case ' ':
  499.                     LINK->zust = konstende;
  500.                     break;
  501.                 
  502.                 case '=':
  503.                 case '\0':
  504.                     LINK->zust = ende;
  505.                     break;
  506.  
  507.                 default:
  508.                     if (isdigit(LINK->ausdruck[LINK->st_index - 1]) ||
  509. /*
  510.                         LINK->ausdruck[LINK->st_index - 1] == ',' ||
  511. */
  512.                         LINK->ausdruck[LINK->st_index - 1] == '.') 
  513.                     {
  514.                         strcat(LINK->konst_str, " ");
  515.                         LINK->konst_str[strlen(LINK->konst_str) - 1] =
  516.                             LINK->ausdruck[LINK->st_index - 1];
  517.                     } 
  518.                     else 
  519.                     {
  520.                         *LINK->fcode = 8;
  521.                         LINK->zust = fehler;
  522.                     }
  523.                     break;
  524.             }
  525.             if (LINK->zust != konstante && *LINK->fcode == 0) 
  526.             {
  527.                 if (strlen(LINK->konst_str) < '\036') 
  528.                 {
  529.                     LINK->code = (sscanf(LINK->konst_str, "%lg", &LINK->xreg) == 0);
  530.                     if (LINK->code == 0) 
  531.                     {
  532.                         if (!LINK->vorz) 
  533.                         {
  534.                             LINK->xreg = -LINK->xreg;
  535.                             LINK->vorz = TRUE;
  536.                         }
  537.                         strcpy(LINK->konst_str, "0");
  538.                     } 
  539.                     else 
  540.                     {
  541.                         *LINK->fcode = 16;
  542.                         LINK->zust = fehler;
  543.                     }
  544.                 } 
  545.                 else 
  546.                 {
  547.                     *LINK->fcode = 16;
  548.                     LINK->zust = fehler;
  549.                 }
  550.             }
  551.             break;
  552.  
  553.         case konstende:
  554.             LINK->st_index++;
  555. /*
  556.             case upcase(ausdruck[st_index]) of
  557. */
  558.             switch (LINK->ausdruck[LINK->st_index - 1]) 
  559.             {
  560.  
  561.                 case '+':
  562.                 case '-':
  563.                 case '*':
  564.                 case '/':
  565.                     LINK->zust = operator1;
  566.                     break;
  567.                 
  568.                 case ')':
  569.                     LINK->zust = klzu1;
  570.                     break;
  571.                 
  572.                 case ' ':
  573.                     /* blank case */
  574.                     break;
  575.                 
  576.                 case '=':
  577.                 case '\0':
  578.                     LINK->zust = ende;
  579.                     break;
  580.                 
  581.                 default:
  582.                     *LINK->fcode = 14;
  583.                     LINK->zust = fehler;
  584.                     break;
  585.             }
  586.             break;
  587.  
  588.         case operator1:
  589.             LINK->opanz++;
  590.             LINK->op[LINK->opanz - 1] = LINK->ausdruck[LINK->st_index - 1];
  591.             berechnen(LINK);
  592.             if (*LINK->fcode == 0)
  593.                 LINK->zust = operator2;
  594.             else
  595.                 LINK->zust = fehler;
  596.             break;
  597.  
  598.         case operator2:
  599.             LINK->st_index++;
  600. /*
  601.             case upcase(ausdruck[st_index]) of
  602. */
  603.             switch (LINK->ausdruck[LINK->st_index - 1]) 
  604.             {
  605.  
  606.                 case '(':
  607.                     LINK->zust = klauf1;
  608.                     break;
  609.  
  610.                 case '+':
  611.                     LINK->vorz = TRUE;
  612.                     LINK->zust = vorzeichen;
  613.                     break;
  614.                 
  615.                 case '-':
  616.                     LINK->vorz = FALSE;
  617.                     LINK->zust = vorzeichen;
  618.                     break;
  619.                 
  620.                 case ' ':
  621.                     /* blank case */
  622.                     break;
  623.                 
  624.                 case '=':
  625.                 case '\0':
  626.                     LINK->zust = ende;
  627.                     break;
  628.  
  629.                 default:
  630.                 if (isdigit(LINK->ausdruck[LINK->st_index - 1]) ||
  631. /*
  632.                     LINK->ausdruck[LINK->st_index - 1] == ',' ||
  633. */
  634.                     LINK->ausdruck[LINK->st_index - 1] == '.') 
  635.                 {
  636.                     strcat(LINK->konst_str, " ");
  637.                     LINK->konst_str[strlen(LINK->konst_str) - 1] =
  638.                         LINK->ausdruck[LINK->st_index - 1];
  639.                     LINK->akt_pos = LINK->st_index;
  640.                     LINK->zust = konstante;
  641.                 } 
  642.                 else 
  643.                     if (isalpha(LINK->ausdruck[LINK->st_index - 1]) ||
  644.                         (LINK->ausdruck[LINK->st_index - 1] & 255) == 142 ||
  645.                         (LINK->ausdruck[LINK->st_index - 1] & 255) == 153 ||
  646.                         (LINK->ausdruck[LINK->st_index - 1] & 255) == 154) 
  647.                     {
  648. /*
  649.                         var_name:=upcase(ausdruck[st_index]);
  650. */
  651.                         LINK->var_name[0] = LINK->ausdruck[LINK->st_index - 1];
  652.                         LINK->var_name[1] = 0;
  653.                         LINK->akt_pos = LINK->st_index;
  654.                         LINK->zust = variable;
  655.                     } 
  656.                     else 
  657.                     {
  658.                         *LINK->fcode = 9;
  659.                         LINK->zust = fehler;
  660.                     }
  661.                     break;
  662.             }
  663.             break;
  664.  
  665.         case vorzeichen:
  666.             LINK->st_index++;
  667. /*
  668.             case upcase(ausdruck[st_index]) of
  669. */
  670.             switch (LINK->ausdruck[LINK->st_index - 1]) 
  671.             {
  672.  
  673.                 case '(':
  674.                     LINK->zust = klauf1;
  675.                     break;
  676.                 
  677.                 case ' ':
  678.                     /* blank case */
  679.                     break;
  680.                 
  681.                 case '=':
  682.                 case '\0':
  683.                     LINK->zust = ende;
  684.                     break;
  685.                 
  686.                 default:
  687.                     if (isdigit(LINK->ausdruck[LINK->st_index - 1]) ||
  688. /*
  689.                         LINK->ausdruck[LINK->st_index - 1] == ',' ||
  690. */
  691.                         LINK->ausdruck[LINK->st_index - 1] == '.') 
  692.                     {
  693.                         strcat(LINK->konst_str, " ");
  694.                         LINK->konst_str[strlen(LINK->konst_str) - 1] =
  695.                             LINK->ausdruck[LINK->st_index - 1];
  696.                         LINK->akt_pos = LINK->st_index;
  697.                         LINK->zust = konstante;
  698.                     } 
  699.                     else 
  700.                     if (isalpha(LINK->ausdruck[LINK->st_index - 1]) ||
  701.                         (LINK->ausdruck[LINK->st_index - 1] & 255) == 142 ||
  702.                         (LINK->ausdruck[LINK->st_index - 1] & 255) == 153 ||
  703.                         (LINK->ausdruck[LINK->st_index - 1] & 255) == 154) 
  704.                     {
  705. /*
  706.                         var_name:=upcase(ausdruck[st_index]);
  707. */
  708.                         LINK->var_name[0] = LINK->ausdruck[LINK->st_index - 1];
  709.                         LINK->var_name[1] = 0;
  710.                         LINK->akt_pos = LINK->st_index;
  711.                         LINK->zust = variable;
  712.                     } 
  713.                     else 
  714.                     {
  715.                         *LINK->fcode = 10;
  716.                         LINK->zust = fehler;
  717.                     }
  718.                     break;
  719.             }
  720.             break;
  721.  
  722.         case klauf1:
  723.             klammer_auf(LINK);
  724.             if (*LINK->fcode == 0)
  725.                 LINK->zust = klauf2;
  726.             else
  727.                 LINK->zust = fehler;
  728.             break;
  729.  
  730.         case klauf2:
  731.             LINK->st_index++;
  732. /*
  733.             case upcase(ausdruck[st_index]) of
  734. */
  735.             switch (LINK->ausdruck[LINK->st_index - 1]) 
  736.             {
  737.             
  738.                 case '+':
  739.                     LINK->vorz = TRUE;
  740.                     LINK->zust = vorzeichen;
  741.                     break;
  742.                     
  743.                 case '-':
  744.                     LINK->vorz = FALSE;
  745.                     LINK->zust = vorzeichen;
  746.                     break;
  747.                     
  748.                 case '(':
  749.                     LINK->zust = klauf1;
  750.                     break;
  751.                     
  752.                 case ')':
  753.                     LINK->zust = klzu1;
  754.                     break;
  755.                     
  756.                 case ' ':
  757.                     /* blank case */
  758.                     break;
  759.                     
  760.                 case '=':
  761.                 case '\0':
  762.                     LINK->zust = ende;
  763.                     break;
  764.                     
  765.                 default:
  766.                     if (isdigit(LINK->ausdruck[LINK->st_index - 1]) ||
  767. /*
  768.                         LINK->ausdruck[LINK->st_index - 1] == ',' ||
  769. */
  770.                         LINK->ausdruck[LINK->st_index - 1] == '.') 
  771.                     {
  772.                         strcat(LINK->konst_str, " ");
  773.                         LINK->konst_str[strlen(LINK->konst_str) - 1] =
  774.                             LINK->ausdruck[LINK->st_index - 1];
  775.                         LINK->akt_pos = LINK->st_index;
  776.                         LINK->zust = konstante;
  777.                     } 
  778.                     else 
  779.                         if (isalpha(LINK->ausdruck[LINK->st_index - 1]) ||
  780.                             (LINK->ausdruck[LINK->st_index - 1] & 255) == 142 ||
  781.                             (LINK->ausdruck[LINK->st_index - 1] & 255) == 153 ||
  782.                             (LINK->ausdruck[LINK->st_index - 1] & 255) == 154) 
  783.                         {
  784. /*
  785.                             var_name:=upcase(ausdruck[st_index]);
  786. */
  787.                             LINK->var_name[0] = LINK->ausdruck[LINK->st_index - 1];
  788.                             LINK->var_name[1] = 0;
  789.                             LINK->akt_pos = LINK->st_index;
  790.                             LINK->zust = variable;
  791.                         } 
  792.                         else 
  793.                         {
  794.                             *LINK->fcode = 11;
  795.                             LINK->zust = fehler;
  796.                         }
  797.                         break;
  798.             }
  799.             break;
  800.  
  801.         case klzu1:
  802.             klammer_zu(LINK);
  803.             if (*LINK->fcode == 0)
  804.                 LINK->zust = klzu2;
  805.             else
  806.                 LINK->zust = fehler;
  807.             break;
  808.  
  809.         case klzu2:
  810.             LINK->st_index++;
  811.             switch (LINK->ausdruck[LINK->st_index - 1]) 
  812.             {
  813.  
  814.                 case '+':
  815.                 case '-':
  816.                 case '*':
  817.                 case '/':
  818.                     LINK->zust = operator1;
  819.                     break;
  820.                 
  821.                 case ')':
  822.                     LINK->zust = klzu1;
  823.                     break;
  824.                 
  825.                 case ' ':
  826.                     /* blank case */
  827.                     break;
  828.                 
  829.                 case '=':
  830.                 case '\0':
  831.                     LINK->zust = ende;
  832.                     break;
  833.                 
  834.                 default:
  835.                     *LINK->fcode = 12;
  836.                     LINK->zust = fehler;
  837.                     break;
  838.             }
  839.             break;
  840.  
  841.         case fehler:
  842.             if (*LINK->fcode == 16 || *LINK->fcode == 17)
  843.                 *LINK->ergebnis = LINK->akt_pos;
  844.             else
  845.                 *LINK->ergebnis = LINK->st_index;
  846.             LINK->fertig = TRUE;
  847.             break;
  848.  
  849.         case ende:
  850.             if (LINK->kli != 0) 
  851.             {
  852.                 *LINK->fcode = 6;   /*Klammeranzahl falsch*/
  853.                 LINK->zust = fehler;
  854.             } 
  855.             else 
  856.             {
  857.                 LINK->opanz++;
  858.                 LINK->op[LINK->opanz - 1] = '+';
  859.                 berechnen(LINK);
  860.                 if (*LINK->fcode == 0) 
  861.                 {
  862.                     if (LINK->xreg > LINK->ober_grenze || LINK->xreg < LINK->unter_grenze) 
  863.                     {
  864.                         if (LINK->xreg > LINK->ober_grenze)   /*Zahl zu klein*/
  865.                             *LINK->fcode = 2;   /*Zahl zu groβ*/
  866.                         else
  867.                             *LINK->fcode = 3;
  868.                         LINK->zust = fehler;
  869.                     } 
  870.                     else 
  871.                     {
  872.                         *LINK->ergebnis = LINK->xreg;
  873.                         LINK->fertig = TRUE;
  874.                     }
  875.                 } 
  876.                 else
  877.                     LINK->zust = fehler;
  878.             }
  879.             break;
  880.     }/*case zust of*/
  881. }  /*task*/
  882.  
  883.  
  884. void entwicklung(    char *ausdruck_, 
  885.                         double unter_grenze_, 
  886.                         double ober_grenze_,
  887.                         double *ergebnis_, 
  888.                         int *fcode_)
  889. {
  890.     struct LOC_entwicklung V;
  891.  
  892.     strcpy(V.ausdruck, ausdruck_);
  893.     V.unter_grenze = unter_grenze_;
  894.     V.ober_grenze = ober_grenze_;
  895.     V.ergebnis = ergebnis_;
  896.     V.fcode = fcode_;
  897.     V.zust = start;
  898.     *V.fcode = 0;   /*bisher kein Fehler*/
  899.     V.kli = 0;
  900.     V.opanz = 0;
  901.     V.xreg = 0.0;
  902.     V.yreg = 0.0;
  903.     V.zreg = 0.0;
  904.     strcpy(V.konst_str, "0");
  905.     V.st_index = 0;
  906.     V.akt_pos = 1;
  907. /*ausdruck:=ohne_blanks(ausdruck);*/
  908. /*Alle Blanks des Strings löschen*/
  909.     strcat(V.ausdruck, " ");   /*00 als Endekennung anhängen*/
  910.     V.ausdruck[strlen(V.ausdruck) - 1] = '\0';
  911.     V.vorz = TRUE;   /*Vorzeichen als default auf plus setzen*/
  912.     V.fertig = FALSE;
  913.     do 
  914.     {
  915.         task(&V);
  916.     } 
  917.     while (!V.fertig);
  918. }  /*entwicklung*/
  919.  
  920. #undef maxkli
  921.  
  922. double interpretiere(char *gleichung, int *fcode)
  923. {
  924.     double ergebnis;
  925.     
  926.     entwicklung(gleichung,-10E+4932, 10E+4932, &ergebnis, fcode);
  927.     return ergebnis;
  928. }
  929.